home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / awe2-0_1.lha / awe2-0.1 / Src / RCS / Facility.cc,v < prev    next >
Text File  |  1989-05-04  |  8KB  |  449 lines
  1. head     3.2;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    grunwald:3.2; strict;
  6. comment  @@;
  7.  
  8.  
  9. 3.2
  10. date     89.02.20.15.34.28;  author grunwald;  state Exp;
  11. branches ;
  12. next     3.1;
  13.  
  14. 3.1
  15. date     88.12.20.13.48.43;  author grunwald;  state Exp;
  16. branches ;
  17. next     1.2;
  18.  
  19. 1.2
  20. date     88.10.30.13.04.24;  author grunwald;  state Exp;
  21. branches ;
  22. next     1.1;
  23.  
  24. 1.1
  25. date     88.09.18.16.42.20;  author grunwald;  state Exp;
  26. branches ;
  27. next     ;
  28.  
  29.  
  30. desc
  31. @@
  32.  
  33.  
  34. 3.2
  35. log
  36. @Start using Gnu library heaps for schedulers
  37. @
  38. text
  39. @// This may look like C code, but it is really -*- C++ -*-
  40. // 
  41. // Copyright (C) 1988 University of Illinois, Urbana, Illinois
  42. //
  43. // written by Dirk Grunwald (grunwald@@cs.uiuc.edu)
  44. //
  45. #include "SimulationMultiplexor.h"
  46. #include "Facility.h"
  47. #include "FifoScheduler.h"
  48. #include "Thread.h"
  49. #include "assert.h"
  50. #include <math.h>
  51.  
  52. Facility::Facility(int xservers, ThreadContainer *xscheduler,
  53.            bool debug)
  54.     : (xservers,xscheduler,debug)
  55. {
  56.     //
  57.     //    Can't use reset because we need to set up service times with
  58.     // NullTime value.
  59.     //
  60.     servers = xservers;
  61.     totalServiceTime = 0.0;
  62.  
  63.     pTotalReserves = 0;
  64.     pTotalFailures = 0;
  65.  
  66.     pTotalDelay = 0.0;
  67.     serviceStarted = CurrentSimulatedTime;
  68.     
  69.     if (servers == 1) {
  70.     whenServiced.single = NullTime;
  71.     } else {
  72.     whenServiced.many = new double[servers];
  73.     for (int i = 0; i < servers; i++) {
  74.         whenServiced.many[i] = NullTime;
  75.     }
  76.     }
  77. }
  78.  
  79. //
  80. //    To reset a facility, we assume that there has been no service
  81. //    so far (totalServiceTime = 0) and then set the beginning of
  82. //    outstanding service intervals to be now.
  83. //
  84. //    Thus, right after being reset, a facility has a utilization of zero.
  85. //
  86. void
  87. Facility::reset()
  88. {
  89.     dataLock.reserve();
  90.  
  91.     double now = CurrentSimulatedTime;
  92.     totalServiceTime = 0.0;
  93.  
  94.     pTotalReserves = 0;
  95.     pTotalFailures = 0;
  96.  
  97.     pTotalDelay = 0.0;
  98.     serviceStarted = now;
  99.     if (servers == 1) {
  100.     if (whenServiced.single != NullTime) {
  101.         whenServiced.single = now;
  102.     }
  103.     } else {
  104.     for (int i = 0; i < servers; i++) {
  105.         if (whenServiced.many[i] != NullTime) {
  106.         whenServiced.many[i] = now;
  107.         }
  108.     }
  109.     }
  110.     dataLock.release();
  111. }
  112.  
  113. Facility::~Facility()
  114. {
  115.     dataLock.reserve();
  116.  
  117.     int error = 0;
  118.     if (servers == 1) {
  119.     error = (whenServiced.single != NullTime);
  120.     } else {
  121.     for(int i = 0; i < servers; i++) {
  122.         error |= (whenServiced.many[i] != NullTime);
  123.     }
  124.     }
  125.  
  126.     if (error) {
  127.     cerr << "[Facility:~Facility]";
  128.     cerr << "Attempted to de-allocate reserved facility\n";
  129.     cerr << *this;
  130.     exit(1);
  131.     }
  132.  
  133.     dataLock.release();
  134. }
  135.  
  136. void Facility::commonReserve(double delayTime)
  137. {
  138.  
  139.     dataLock.reserve();
  140.     
  141.     pTotalReserves++;
  142.     pTotalDelay += delayTime;
  143.  
  144.     if (servers == 1) {
  145.     if (whenServiced.single == NullTime) {
  146.         whenServiced.single = CurrentSimulatedTime;
  147.         dataLock.release();
  148.         return;
  149.     }
  150.     } else {
  151.     for (int i = 0; i < servers; i++) {
  152.         if (whenServiced.many[i] == NullTime) {
  153.         whenServiced.many[i] = CurrentSimulatedTime;
  154.         dataLock.release();
  155.         return;
  156.         }
  157.     }
  158.     }
  159.  
  160.     dataLock.release();    // need to release so reportErrorState works
  161.  
  162.     reportErrorState(cerr);
  163.     assert2(FALSE, "[Facility] state error with facility semaphore");
  164. }
  165.  
  166. void Facility::reserve()
  167. {
  168.     double startedReserve = CurrentSimulatedTime;
  169.     Semaphore::reserve();
  170.     commonReserve( CurrentSimulatedTime - startedReserve );
  171. }
  172.  
  173. void
  174. Facility::use(double howLong)
  175. {
  176.     reserve();
  177.     hold(howLong);
  178.     release();
  179. }
  180.  
  181. bool Facility::reserveNoBlock()
  182. {
  183.     if (Semaphore::reserveNoBlock()) {
  184.     commonReserve(0.0);    // commonReserve will bumb pTotalReserves
  185.     return(TRUE);
  186.     } else {
  187.     dataLock.reserve();
  188.  
  189.     pTotalFailures++;
  190.  
  191.     dataLock.release();
  192.  
  193.     return(FALSE);
  194.     }
  195. }
  196.  
  197. void Facility::release()
  198. {
  199.     dataLock.reserve();
  200.  
  201.     double now = CurrentSimulatedTime;
  202.     bool error = 0;
  203.     
  204.     if (servers == 1) {
  205.     if (whenServiced.single != NullTime) {
  206.         totalServiceTime += (now - whenServiced.single);
  207.         whenServiced.single = NullTime;
  208.     } else {
  209.         error = 1;
  210.     }
  211.     } else {
  212.     error = 1;
  213.     for (int i = 0; i < servers; i++) {
  214.         if (whenServiced.many[i] != NullTime) {
  215.         totalServiceTime += (now - whenServiced.many[i]);
  216.         whenServiced.many[i] = NullTime;
  217.         error = 0;
  218.         break;
  219.         }
  220.     }
  221.     }
  222.  
  223.     dataLock.release();
  224.     
  225.     if (error) {
  226.     cerr << "[Facility::release] ";
  227.     cerr << "Attempt to release un-reserved facility\n";
  228.     cerr << *this;
  229.     exit(1);
  230.     }
  231.     Semaphore::release();
  232. }
  233.  
  234. double Facility::utilization()
  235. {
  236.     //
  237.     //    To compute utilization, we sum the outstanding request times,
  238.     //    add in the current total service time, and divide this by
  239.     //    the number of facilities & the number servers.
  240.     // 
  241.  
  242.     dataLock.reserve();
  243.     
  244.     double totalTime = totalServiceTime;
  245.     double now = CurrentSimulatedTime;
  246.     
  247.     if (servers == 1) {
  248.     if (whenServiced.single != NullTime) {
  249.         totalTime += (now - whenServiced.single);
  250.     }
  251.     } else {
  252.     for (int i = 0; i < servers; i++) {
  253.         if (whenServiced.many[i] != NullTime) {
  254.         totalTime += (now - whenServiced.many[i]);
  255.         }
  256.     }
  257.     }
  258.     
  259.     if (now == serviceStarted) {
  260.     totalTime = 0;
  261.     } else {
  262.     totalTime /= (servers * (now - serviceStarted));
  263.     }
  264.     dataLock.release();
  265.     return(totalTime);
  266. }
  267.  
  268. double
  269. Facility::perceivedUtilization()
  270. {
  271.     dataLock.reserve();
  272.     double util = 0;
  273.     long pTotal = pTotalReserves + pTotalFailures;
  274.     if ( pTotal >0 ) {
  275.     util = pTotalFailures;
  276.     util /= pTotal;
  277.     }
  278.     dataLock.release();
  279.     return( util );
  280. }
  281.  
  282. long
  283. Facility::totalAttempts()
  284. {
  285.     dataLock.reserve();
  286.     int res = pTotalReserves + pTotalFailures;
  287.     dataLock.release();
  288.     return(res);
  289. }
  290.  
  291. long
  292. Facility::totalReserves()
  293. {
  294.     dataLock.reserve();
  295.     int res = pTotalReserves;
  296.     dataLock.release();
  297.     return(res);
  298. }
  299.  
  300. long
  301. Facility::totalFailures()
  302. {
  303.     dataLock.reserve();
  304.     int res = pTotalFailures;
  305.     dataLock.release();
  306.     return(res);
  307. }
  308.  
  309. double
  310. Facility::totalDelay()
  311. {
  312.     return(pTotalDelay);
  313. }
  314.  
  315. double
  316. Facility::meanDelay()
  317. {
  318.     if (pTotalReserves > 0) {
  319.     return( pTotalDelay / pTotalReserves);
  320.     } else {
  321.     return( 0.0 );
  322.     }
  323. }
  324.  
  325. unsigned Facility::queueLength()
  326. {
  327.     return(Semaphore::size());
  328. }
  329.  
  330. unsigned Facility::activeServers()
  331. {
  332.     dataLock.reserve();
  333.  
  334.     int outStanding = 0;
  335.     if (servers == 1) {
  336.     if (whenServiced.single != NullTime) {
  337.         outStanding++;
  338.     }
  339.     } else {
  340.     for (int i = 0; i < servers; i++ ){
  341.         if (whenServiced.many[i] != NullTime) {
  342.         outStanding++;
  343.         }
  344.     }
  345.     }
  346.     dataLock.release();
  347.  
  348.     return(outStanding);
  349. }
  350.  
  351. unsigned Facility::size()
  352. {
  353.     return(queueLength() + activeServers());
  354. }
  355.  
  356. bool Facility::isEmpty()
  357. {
  358.     return(size() == 0);
  359. }
  360.  
  361. void Facility::classPrintOn(ostream &out)
  362. {
  363.     out << "Facility with " << activeServers() << " active servers and "
  364.     << queueLength() << " queued requests";
  365. }
  366.  
  367. void Facility::reportErrorState(ostream &out)
  368. {
  369.     out << *this << "\n";
  370.     out << "Serviced started at " << serviceStarted
  371.     << " with a total service time of " << totalServiceTime << "\n";
  372.     if (servers == 1) {
  373.     out << "Server 1 ";
  374.     if (whenServiced.single == NullTime) {
  375.         out << " is idle\n";
  376.     } else {
  377.         out << " started serving at " << whenServiced.single << "\n";
  378.     }
  379.     } else {
  380.     for (int i = 0; i < servers; i++) {
  381.         out << "Server " << i ;
  382.         if (whenServiced.many[i] == NullTime) {
  383.         out << " is idle\n";
  384.         } else {
  385.         out << " started serving at " << whenServiced.many[i] << "\n";
  386.         }
  387.     }
  388.     }
  389.     out << "State of facility semaphore is:\n";
  390.     Semaphore::classPrintOn(out);
  391. }
  392. @
  393.  
  394.  
  395. 3.1
  396. log
  397. @Steay version
  398. @
  399. text
  400. @d51 2
  401. d72 1
  402. @
  403.  
  404.  
  405. 1.2
  406. log
  407. @*** empty log message ***
  408. @
  409. text
  410. @d24 1
  411. d26 2
  412. d53 1
  413. d55 2
  414. d102 1
  415. d143 1
  416. a143 1
  417.     commonReserve(0.0);
  418. d146 6
  419. d227 24
  420. a250 1
  421. int
  422. d255 9
  423. @
  424.  
  425.  
  426. 1.1
  427. log
  428. @Initial revision
  429. @
  430. text
  431. @d1 7
  432. a7 1
  433. #include "HardwareCpu.h"
  434. d25 1
  435. d51 1
  436. d89 1
  437. a89 1
  438. void Facility::commonReserve()
  439. d95 1
  440. d120 1
  441. d122 1
  442. a122 1
  443.     commonReserve();
  444. d136 1
  445. a136 1
  446.     commonReserve();
  447. d221 16
  448. @
  449.